{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional VAE Example\n",
    "\n",
    "This notebook demonstrates how to build a Conditional Variational Autoencoder (CVAE) [3]. We will train a CVAE to generate images of handwritten digits (0-9) given a label. Like VAE [1], CVAE will be built in CNN using PyTorch and trained on the MNIST dataset [2].\n",
    "\n",
    "References:\n",
    "- [1] Kingma, Diederik P., and Max Welling. \"Auto-encoding variational bayes.\" arXiv preprint arXiv:1312.6114 (2013).\n",
    "- [2] LeCun, Yann, and Corinna Cortes. \"MNIST handwritten digit database.\" (2010).\n",
    "- [3] Sohn, Kihyuk, Honglak Lee, and Xinchen Yan. \"Learning structured output representation using deep conditional generative models.\" Advances in neural information processing systems. 2015.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/rowel/anaconda3/envs/speech/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Architecture\n",
    "\n",
    "The CVAE is a generative model that learns a latent variable model for its input data. The main difference of CVAE from VAE is that CVAE learns a conditional distribution $p(x|y)$ instead of $p(x)$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(Encoder, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(2, 32, kernel_size=3, stride=2, padding=1)\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1)\n",
    "        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)\n",
    "        self.proj = nn.Linear(10, 1*28*28)\n",
    "        \n",
    "    def forward(self, x, y):\n",
    "        y = self.proj(y).reshape(-1, 1, 28, 28)\n",
    "        x = torch.cat([x, y], dim=1)\n",
    "        x = nn.functional.relu(self.conv1(x))\n",
    "        x = nn.functional.relu(self.conv2(x))\n",
    "        x = nn.functional.relu(self.conv3(x))\n",
    "        x = x.flatten(1)\n",
    "        return x\n",
    "\n",
    "class Decoder(nn.Module):\n",
    "    def __init__(self, latent_dim=2):\n",
    "        super(Decoder, self).__init__()\n",
    "        self.fc = nn.Linear(latent_dim, 128*4*4)\n",
    "        self.conv1 = nn.ConvTranspose2d(128*2, 64, kernel_size=3, stride=2, padding=1, output_padding=0)\n",
    "        self.conv2 = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.conv3 = nn.ConvTranspose2d(32, 1, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.proj = nn.Linear(10, 128*4*4)\n",
    "        \n",
    "    def forward(self, x, y):\n",
    "        y = self.proj(y).reshape(-1, 128, 4, 4)\n",
    "        x = self.fc(x)\n",
    "        x = x.view(-1, 128, 4, 4)\n",
    "        x = torch.cat([x, y], dim=1)\n",
    "        x = nn.functional.relu(self.conv1(x))\n",
    "        x = nn.functional.relu(self.conv2(x))\n",
    "        x = torch.sigmoid(self.conv3(x))\n",
    "        return x\n",
    "    \n",
    "\n",
    "class CNN_VAE(nn.Module):\n",
    "    def __init__(self, latent_dim=2):\n",
    "        super(CNN_VAE, self).__init__()\n",
    "        self.encoder = Encoder()\n",
    "        self.decoder = Decoder(latent_dim=latent_dim)\n",
    "        self.fc_mu = nn.Linear(128*4*4, latent_dim)\n",
    "        self.fc_logvar = nn.Linear(128*4*4, latent_dim)\n",
    "        \n",
    "    def encode(self, x, y):\n",
    "        x = self.encoder(x, y)\n",
    "        mu = self.fc_mu(x)\n",
    "        logvar = self.fc_logvar(x)\n",
    "        return mu, logvar\n",
    "    \n",
    "    def reparameterize(self, mu, logvar):\n",
    "        std = torch.exp(0.5 * logvar)\n",
    "        eps = torch.randn_like(std)\n",
    "        z = mu + eps * std\n",
    "        return z\n",
    "    \n",
    "    def decode(self, z, y):\n",
    "        return self.decoder(z, y)\n",
    "    \n",
    "    def forward(self, x, y):\n",
    "        mu, logvar = self.encode(x, y)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        x_recon = self.decode(z, y)\n",
    "        return x_recon, mu, logvar\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Training\n",
    "\n",
    "Like VAE, CVAE is trained on the MNIST dataset. The main difference is the use of label (a condition) for training:\n",
    "\n",
    "```\n",
    "label = label.to(device).long()  # Convert label to long type\n",
    "label_one_hot = torch.nn.functional.one_hot(label, num_classes=10).float() \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CNN_VAE(\n",
      "  (encoder): Encoder(\n",
      "    (conv1): Conv2d(2, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (conv2): Conv2d(32, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (conv3): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (proj): Linear(in_features=10, out_features=784, bias=True)\n",
      "  )\n",
      "  (decoder): Decoder(\n",
      "    (fc): Linear(in_features=2, out_features=2048, bias=True)\n",
      "    (conv1): ConvTranspose2d(256, 64, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))\n",
      "    (conv2): ConvTranspose2d(64, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
      "    (conv3): ConvTranspose2d(32, 1, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), output_padding=(1, 1))\n",
      "    (proj): Linear(in_features=10, out_features=2048, bias=True)\n",
      "  )\n",
      "  (fc_mu): Linear(in_features=2048, out_features=2, bias=True)\n",
      "  (fc_logvar): Linear(in_features=2048, out_features=2, bias=True)\n",
      ")\n",
      "Number of model parameters: 0.30 million\n",
      "Running on: cuda\n",
      "Epoch [1/30], Recon Loss: 0.050155, KL Loss: 0.002500, LR: 0.000997\n",
      "Epoch [2/30], Recon Loss: 0.037079, KL Loss: 0.003955, LR: 0.000989\n",
      "Epoch [3/30], Recon Loss: 0.035726, KL Loss: 0.004150, LR: 0.000976\n",
      "Epoch [4/30], Recon Loss: 0.035118, KL Loss: 0.004231, LR: 0.000957\n",
      "Epoch [5/30], Recon Loss: 0.034734, KL Loss: 0.004290, LR: 0.000933\n",
      "Epoch [6/30], Recon Loss: 0.034483, KL Loss: 0.004324, LR: 0.000905\n",
      "Epoch [7/30], Recon Loss: 0.034273, KL Loss: 0.004346, LR: 0.000872\n",
      "Epoch [8/30], Recon Loss: 0.034103, KL Loss: 0.004381, LR: 0.000835\n",
      "Epoch [9/30], Recon Loss: 0.033976, KL Loss: 0.004380, LR: 0.000794\n",
      "Epoch [10/30], Recon Loss: 0.033872, KL Loss: 0.004402, LR: 0.000750\n",
      "Epoch [11/30], Recon Loss: 0.033746, KL Loss: 0.004424, LR: 0.000703\n",
      "Epoch [12/30], Recon Loss: 0.033650, KL Loss: 0.004429, LR: 0.000655\n",
      "Epoch [13/30], Recon Loss: 0.033562, KL Loss: 0.004446, LR: 0.000604\n",
      "Epoch [14/30], Recon Loss: 0.033482, KL Loss: 0.004461, LR: 0.000552\n",
      "Epoch [15/30], Recon Loss: 0.033399, KL Loss: 0.004459, LR: 0.000500\n",
      "Epoch [16/30], Recon Loss: 0.033324, KL Loss: 0.004479, LR: 0.000448\n",
      "Epoch [17/30], Recon Loss: 0.033259, KL Loss: 0.004493, LR: 0.000396\n",
      "Epoch [18/30], Recon Loss: 0.033185, KL Loss: 0.004495, LR: 0.000345\n",
      "Epoch [19/30], Recon Loss: 0.033123, KL Loss: 0.004503, LR: 0.000297\n",
      "Epoch [20/30], Recon Loss: 0.033069, KL Loss: 0.004517, LR: 0.000250\n",
      "Epoch [21/30], Recon Loss: 0.033002, KL Loss: 0.004517, LR: 0.000206\n",
      "Epoch [22/30], Recon Loss: 0.032953, KL Loss: 0.004510, LR: 0.000165\n",
      "Epoch [23/30], Recon Loss: 0.032905, KL Loss: 0.004534, LR: 0.000128\n",
      "Epoch [24/30], Recon Loss: 0.032867, KL Loss: 0.004540, LR: 0.000095\n",
      "Epoch [25/30], Recon Loss: 0.032831, KL Loss: 0.004541, LR: 0.000067\n",
      "Epoch [26/30], Recon Loss: 0.032798, KL Loss: 0.004544, LR: 0.000043\n",
      "Epoch [27/30], Recon Loss: 0.032767, KL Loss: 0.004541, LR: 0.000024\n",
      "Epoch [28/30], Recon Loss: 0.032750, KL Loss: 0.004550, LR: 0.000011\n",
      "Epoch [29/30], Recon Loss: 0.032736, KL Loss: 0.004551, LR: 0.000003\n",
      "Epoch [30/30], Recon Loss: 0.032713, KL Loss: 0.004548, LR: 0.000000\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "vae = CNN_VAE().to(device)\n",
    "\n",
    "print(vae)\n",
    "print(f\"Number of model parameters: {sum(p.numel() for p in vae.parameters())/1e6:.2f} million\")\n",
    "print(f\"Running on: {device}\")\n",
    "\n",
    "# Define the batch size for the dataloaders\n",
    "batch_size = 128\n",
    "\n",
    "# Load the MNIST train dataset\n",
    "train_dataset = torchvision.datasets.MNIST(root='~/data', \n",
    "                                           train=True, \n",
    "                                           download=True, \n",
    "                                           transform=transforms.ToTensor())\n",
    "\n",
    "# Create the train dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_dataset, \n",
    "                                           batch_size=batch_size, \n",
    "                                           shuffle=True)\n",
    "\n",
    "# Load the MNIST test dataset\n",
    "test_dataset = torchvision.datasets.MNIST(root='~/data', \n",
    "                                          train=False, \n",
    "                                          download=True, \n",
    "                                          transform=transforms.ToTensor())\n",
    "\n",
    "# Create the test dataloader\n",
    "test_loader = torch.utils.data.DataLoader(test_dataset, \n",
    "                                          batch_size=batch_size, \n",
    "                                          shuffle=False)\n",
    "\n",
    "# Set the number of epochs\n",
    "num_epochs = 30\n",
    "\n",
    "# Define the optimizer and the scheduler\n",
    "optimizer = torch.optim.Adam(vae.parameters(), lr=0.001)\n",
    "scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs)\n",
    "\n",
    "# Set the model to training mode\n",
    "vae.train()\n",
    "\n",
    "acc_loss = []\n",
    "kl_losses = []\n",
    "recon_losses = []\n",
    "\n",
    "# Train the model for the specified number of epochs\n",
    "for epoch in range(num_epochs):\n",
    "    acc_loss = []\n",
    "    recon_losses = []\n",
    "    kl_losses = []\n",
    "    \n",
    "    # Iterate over the training data\n",
    "    for data in train_loader:\n",
    "        # Get the input data\n",
    "        img, label = data\n",
    "        img = img.to(device)\n",
    "        label = label.to(device).long()  # Convert label to long type\n",
    "        label_one_hot = torch.nn.functional.one_hot(label, num_classes=10).float() \n",
    "    \n",
    "        img_size = img.shape[-1] * img.shape[-2]\n",
    "        batch_dim = img.shape[0]\n",
    "        \n",
    "        # Forward pass\n",
    "        recon, mu, logvar = vae(img, label_one_hot)\n",
    "        \n",
    "        # Compute the reconstruction loss\n",
    "        loss = nn.MSELoss()(recon, img)\n",
    "        \n",
    "        # Compute the KL divergence loss\n",
    "        kl_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "        # Normalize to per pixel\n",
    "        kl_loss /= (batch_dim * img_size)\n",
    " \n",
    "        # Add the reconstruction loss and KL divergence loss\n",
    "        total_loss = loss + kl_loss\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        total_loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        acc_loss.append(total_loss.item())\n",
    "        recon_losses.append(loss.item())\n",
    "        kl_losses.append(kl_loss.item())\n",
    "        \n",
    "    scheduler.step()\n",
    "    \n",
    "    # Print the loss and current learning rate for each epoch\n",
    "    print('Epoch [{}/{}], Recon Loss: {:.6f}, KL Loss: {:.6f}, LR: {:.6f}'.format(epoch+1, num_epochs, np.mean(recon_losses), np.mean(kl_losses), optimizer.param_groups[0]['lr']))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model Testing\n",
    "\n",
    "The CVAE is tested on the MNIST test dataset. We can see that the generated images are fully controllable given the label."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x200 with 20 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set the model to evaluation mode\n",
    "vae.eval()\n",
    "\n",
    "# Create empty lists to store the input images and decoded images\n",
    "input_images = []\n",
    "decoded_images = []\n",
    "\n",
    "with torch.no_grad():\n",
    "    # Iterate over the test dataloader\n",
    "    for data in test_loader:\n",
    "        # Get the input data\n",
    "        img, label = data\n",
    "        img = img.to(device)\n",
    "        label = label.to(device).long()  # Convert label to long type\n",
    "        label_one_hot = torch.nn.functional.one_hot(label, num_classes=10).float() \n",
    "\n",
    "        # Flatten the input data\n",
    "        # inputs = inputs.view(inputs.size(0), -1)\n",
    "\n",
    "        # Forward pass\n",
    "        recon_batch, _, _ = vae(img, label_one_hot)\n",
    "    \n",
    "        # Append the input and decoded images to the lists\n",
    "        input_images.append(img.detach().cpu().numpy())\n",
    "        decoded_images.append(recon_batch.detach().cpu().numpy())\n",
    "\n",
    "# Concatenate the input and decoded images\n",
    "input_images = np.concatenate(input_images)\n",
    "decoded_images = np.concatenate(decoded_images)\n",
    "\n",
    "# Reshape the images\n",
    "input_images = input_images.reshape(-1, 28, 28)\n",
    "decoded_images = decoded_images.reshape(-1, 28, 28)\n",
    "\n",
    "# Plot the input and decoded images\n",
    "fig, axes = plt.subplots(2, 10, figsize=(10, 2))\n",
    "\n",
    "for i in range(10):\n",
    "    axes[0, i].imshow(input_images[i], cmap='gray')\n",
    "    axes[0, i].axis('off')\n",
    "    \n",
    "    axes[1, i].imshow(decoded_images[i], cmap='gray')\n",
    "    axes[1, i].axis('off')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Image Generation\n",
    "\n",
    "We can also generate images of a specific label. For example, we can generate images of digits 0-9:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set the model to evaluation mode\n",
    "vae.eval()\n",
    "\n",
    "# Create empty list to store the generated images\n",
    "generated_images = []\n",
    "\n",
    "with torch.no_grad():\n",
    "    # Iterate over the labels from 0 to 9\n",
    "    for label in range(10):\n",
    "        # Create a tensor for the label\n",
    "        label_tensor = torch.tensor(label).unsqueeze(0).to(device)\n",
    "        label_one_hot = torch.nn.functional.one_hot(label_tensor, num_classes=10).float()\n",
    "\n",
    "        # Generate a random latent vector\n",
    "        latent_vector = torch.randn(1, 2).to(device)\n",
    "\n",
    "        # Decode the latent vector to generate an image\n",
    "        generated_image = vae.decode(latent_vector, label_one_hot)\n",
    "\n",
    "        # Append the generated image to the list\n",
    "        generated_images.append(generated_image.detach().cpu().numpy())\n",
    "\n",
    "# Concatenate the generated images\n",
    "generated_images = np.concatenate(generated_images)\n",
    "\n",
    "# Reshape the images\n",
    "generated_images = generated_images.reshape(-1, 28, 28)\n",
    "\n",
    "# Plot the generated images\n",
    "fig, axes = plt.subplots(2, 5, figsize=(10, 4))\n",
    "\n",
    "for i in range(10):\n",
    "    axes[i // 5, i % 5].imshow(generated_images[i], cmap='gray')\n",
    "    axes[i // 5, i % 5].axis('off')\n",
    "\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "fuyu",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
